package com.spark.common.utils;

import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串工具类
 *
 * @author LYCHEE
 * @date 2025/2/18 11:33
 */
public class StringUtils {

    /**
     * 空字符串
     */
    private static final String NULLSTR = "";

    /**
     * * 判断一个字符串是否为空串
     *
     * @param str String
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(String str){
        return isNull(str) || NULLSTR.equals(str.trim());
    }

    /**
     * * 判断一个字符串是否为非空串
     *
     * @param str String
     * @return true：非空串 false：空串
     */
    public static boolean isNotEmpty(String str){
        return !isEmpty(str);
    }

    /**
     * * 判断一个Map是否为空
     *
     * @param map 要判断的Map
     * @return true：非空 false：空
     */
    public static boolean isNotEmpty(Map<?, ?> map){
        return !isEmpty(map);
    }

    /**
     * * 判断一个Map是否为空
     *
     * @param map 要判断的Map
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(Map<?, ?> map) {
        return isNull(map) || map.isEmpty();
    }

    /**
     * 判断一个对象是否为空
     *
     * @param object Object
     * @return true：为空 false：非空
     */
    public static boolean isNull(Object object) {
        return object == null;
    }

    /**
     * * 判断一个对象是否非空
     *
     * @param object Object
     * @return true：非空 false：空
     */
    public static boolean isNotNull(Object object){
        return !isNull(object);
    }


    /**
     * 将驼峰字符串转为下划线格式
     *
     * @param input 字符
     * @return 转化后的
     */
    public static String camelToUnderscore(String input) {
        if (input == null || input.isEmpty()) {
            return input;
        }
        return input.replaceAll("([a-z])([A-Z])", "$1_$2").toLowerCase();
    }

    /**
     * 将下划线格式的字符串转为驼峰格式
     *
     * @param input 字符串
     * @return 转化后的字符串
     */
    public static String underscoreToCamel(String input) {
        if (input == null || input.isEmpty()) {
            return input;
        }
        // 创建匹配下划线后跟小写字母的正则表达式
        Pattern pattern = Pattern.compile("_(.)");
        Matcher matcher = pattern.matcher(input);
        StringBuffer result = new StringBuffer();
        while (matcher.find()) {
            // 将匹配到的部分（即下划线及其后的小写字母）替换为大写字母
            matcher.appendReplacement(result, matcher.group(1).toUpperCase());
        }
        matcher.appendTail(result);
        return result.toString();
    }

    /**
     * 首字符转换为大写，其余部分保持不变
     *
     * @param str 需要处理的字符串
     * @return 结果
     */
    public static String capitalizeFirstLetter(String str) {
        if (str == null || str.isEmpty()) {
            return str;
        }
        // 如果字符串长度为1，直接转换为大写返回
        if (str.length() == 1) {
            return str.toUpperCase();
        }
        // 首字符转换为大写，其余部分保持不变
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }

    /**
     * 格式化文本, {} 表示占位符<br>
     * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
     *
     * @param template 文本模板，被替换的部分用 {} 表示
     * @param params   参数值
     * @return 格式化后的文本
     */
    public static String format(String template, Object... params) {
        if (params == null || params.length == 0) {
            return template;
        }
        StringBuilder sb = new StringBuilder(template);
        int index = 0;
        for (Object param : params) {
            int placeholderIndex = sb.indexOf("{}", index);
            if (placeholderIndex != -1) {
                // 插入参数值，并删除旧的占位符
                sb.replace(placeholderIndex, placeholderIndex + 2, String.valueOf(param));
                // 更新索引位置，避免重复查找同一位置
                index = placeholderIndex + String.valueOf(param).length();
            } else {
                // 如果没有找到更多的占位符，则停止替换
                break;
            }
        }
        return sb.toString();
    }

}
